        -:    0:Source:/usr/include/c++/14.1.1/bits/stl_construct.h
        -:    0:Graph:/home/kirillg/Coding/MIET/Diploma/cmake-build-debug-coverage/CMakeFiles/Diploma.dir/src/Image.cpp.gcno
        -:    0:Data:/home/kirillg/Coding/MIET/Diploma/cmake-build-debug-coverage/CMakeFiles/Diploma.dir/src/Image.cpp.gcda
        -:    0:Runs:1
        -:    1:// nonstandard construct and destroy functions -*- C++ -*-
        -:    2:
        -:    3:// Copyright (C) 2001-2024 Free Software Foundation, Inc.
        -:    4://
        -:    5:// This file is part of the GNU ISO C++ Library.  This library is free
        -:    6:// software; you can redistribute it and/or modify it under the
        -:    7:// terms of the GNU General Public License as published by the
        -:    8:// Free Software Foundation; either version 3, or (at your option)
        -:    9:// any later version.
        -:   10:
        -:   11:// This library is distributed in the hope that it will be useful,
        -:   12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
        -:   13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        -:   14:// GNU General Public License for more details.
        -:   15:
        -:   16:// Under Section 7 of GPL version 3, you are granted additional
        -:   17:// permissions described in the GCC Runtime Library Exception, version
        -:   18:// 3.1, as published by the Free Software Foundation.
        -:   19:
        -:   20:// You should have received a copy of the GNU General Public License and
        -:   21:// a copy of the GCC Runtime Library Exception along with this program;
        -:   22:// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
        -:   23:// <http://www.gnu.org/licenses/>.
        -:   24:
        -:   25:/*
        -:   26: *
        -:   27: * Copyright (c) 1994
        -:   28: * Hewlett-Packard Company
        -:   29: *
        -:   30: * Permission to use, copy, modify, distribute and sell this software
        -:   31: * and its documentation for any purpose is hereby granted without fee,
        -:   32: * provided that the above copyright notice appear in all copies and
        -:   33: * that both that copyright notice and this permission notice appear
        -:   34: * in supporting documentation.  Hewlett-Packard Company makes no
        -:   35: * representations about the suitability of this software for any
        -:   36: * purpose.  It is provided "as is" without express or implied warranty.
        -:   37: *
        -:   38: *
        -:   39: * Copyright (c) 1996,1997
        -:   40: * Silicon Graphics Computer Systems, Inc.
        -:   41: *
        -:   42: * Permission to use, copy, modify, distribute and sell this software
        -:   43: * and its documentation for any purpose is hereby granted without fee,
        -:   44: * provided that the above copyright notice appear in all copies and
        -:   45: * that both that copyright notice and this permission notice appear
        -:   46: * in supporting documentation.  Silicon Graphics makes no
        -:   47: * representations about the suitability of this software for any
        -:   48: * purpose.  It is provided "as is" without express or implied warranty.
        -:   49: */
        -:   50:
        -:   51:/** @file bits/stl_construct.h
        -:   52: *  This is an internal header file, included by other library headers.
        -:   53: *  Do not attempt to use it directly. @headername{memory}
        -:   54: */
        -:   55:
        -:   56:#ifndef _STL_CONSTRUCT_H
        -:   57:#define _STL_CONSTRUCT_H 1
        -:   58:
        -:   59:#include <new>
        -:   60:#include <bits/move.h>
        -:   61:#include <bits/stl_iterator_base_types.h> // for iterator_traits
        -:   62:#include <bits/stl_iterator_base_funcs.h> // for advance
        -:   63:
        -:   64:/* This file provides the C++17 functions std::destroy_at, std::destroy, and
        -:   65: * std::destroy_n, and the C++20 function std::construct_at.
        -:   66: * It also provides std::_Construct, std::_Destroy,and std::_Destroy_n functions
        -:   67: * which are defined in all standard modes and so can be used in C++98-14 code.
        -:   68: * The _Destroy functions will dispatch to destroy_at during constant
        -:   69: * evaluation, because calls to that function are intercepted by the compiler
        -:   70: * to allow use in constant expressions.
        -:   71: */
        -:   72:
        -:   73:namespace std _GLIBCXX_VISIBILITY(default)
        -:   74:{
        -:   75:_GLIBCXX_BEGIN_NAMESPACE_VERSION
        -:   76:
        -:   77:#if __glibcxx_raw_memory_algorithms // >= C++17
        -:   78:  template <typename _Tp>
        -:   79:    _GLIBCXX20_CONSTEXPR inline void
  4459910:   80:    destroy_at(_Tp* __location)
        -:   81:    {
        -:   82:      if constexpr (__cplusplus > 201703L && is_array_v<_Tp>)
        -:   83:	{
        -:   84:	  for (auto& __x : *__location)
        -:   85:	    std::destroy_at(std::__addressof(__x));
        -:   86:	}
        -:   87:      else
  4459910:   88:	__location->~_Tp();
        -:   89:    }
        -:   90:
        -:   91:#if __cpp_constexpr_dynamic_alloc // >= C++20
        -:   92:  template<typename _Tp, typename... _Args>
        -:   93:    constexpr auto
        -:   94:    construct_at(_Tp* __location, _Args&&... __args)
        -:   95:    noexcept(noexcept(::new((void*)0) _Tp(std::declval<_Args>()...)))
        -:   96:    -> decltype(::new((void*)0) _Tp(std::declval<_Args>()...))
        -:   97:    { return ::new((void*)__location) _Tp(std::forward<_Args>(__args)...); }
        -:   98:#endif // C++20
        -:   99:#endif// C++17
        -:  100:
        -:  101:  /**
        -:  102:   * Constructs an object in existing memory by invoking an allocated
        -:  103:   * object's constructor with an initializer.
        -:  104:   */
        -:  105:#if __cplusplus >= 201103L
        -:  106:  template<typename _Tp, typename... _Args>
        -:  107:    _GLIBCXX20_CONSTEXPR
        -:  108:    inline void
        -:  109:    _Construct(_Tp* __p, _Args&&... __args)
        -:  110:    {
        -:  111:#if __cpp_constexpr_dynamic_alloc // >= C++20
        -:  112:      if (std::__is_constant_evaluated())
        -:  113:	{
        -:  114:	  // Allow std::_Construct to be used in constant expressions.
        -:  115:	  std::construct_at(__p, std::forward<_Args>(__args)...);
        -:  116:	  return;
        -:  117:	}
        -:  118:#endif
        -:  119:      ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
        -:  120:    }
        -:  121:#else
        -:  122:  template<typename _T1, typename _T2>
        -:  123:    inline void
        -:  124:    _Construct(_T1* __p, const _T2& __value)
        -:  125:    {
        -:  126:      // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -:  127:      // 402. wrong new expression in [some_]allocator::construct
        -:  128:      ::new(static_cast<void*>(__p)) _T1(__value);
        -:  129:    }
        -:  130:#endif
        -:  131:
        -:  132:  template<typename _T1>
        -:  133:    inline void
        -:  134:    _Construct_novalue(_T1* __p)
        -:  135:    { ::new((void*)__p) _T1; }
        -:  136:
        -:  137:  template<typename _ForwardIterator>
        -:  138:    _GLIBCXX20_CONSTEXPR void
        -:  139:    _Destroy(_ForwardIterator __first, _ForwardIterator __last);
        -:  140:
        -:  141:  /**
        -:  142:   * Destroy the object pointed to by a pointer type.
        -:  143:   */
        -:  144:  template<typename _Tp>
        -:  145:    _GLIBCXX14_CONSTEXPR inline void
  4459910:  146:    _Destroy(_Tp* __pointer)
  4459910:  146-block 3
переход  0 выполнен 4459910 (fallthrough)
переход  1 выполнен 0
        -:  147:    {
        -:  148:#if __cpp_constexpr_dynamic_alloc // >= C++20
  4459910:  149:      std::destroy_at(__pointer);
        -:  150:#else
        -:  151:      __pointer->~_Tp();
        -:  152:#endif
        -:  153:    }
        -:  154:
        -:  155:  template<bool>
        -:  156:    struct _Destroy_aux
        -:  157:    {
        -:  158:      template<typename _ForwardIterator>
        -:  159:	static _GLIBCXX20_CONSTEXPR void
function _ZNSt12_Destroy_auxILb0EE9__destroyIPSt6vectorI4CellSaIS3_EEEEvT_S7_ called 63713 returned 100% blocks executed 100%
    63713:  160:	__destroy(_ForwardIterator __first, _ForwardIterator __last)
        -:  161:	{
  4523623:  162:	  for (; __first != __last; ++__first)
    63713:  162-block 2
  4523623:  162-block 7
переход  0 выполнен 4459910
переход  1 выполнен 63713 (fallthrough)
  4459910:  163:	    std::_Destroy(std::__addressof(*__first));
  4459910:  163-block 6
    63713:  164:	}
        -:  165:    };
        -:  166:
        -:  167:  template<>
        -:  168:    struct _Destroy_aux<true>
        -:  169:    {
        -:  170:      template<typename _ForwardIterator>
        -:  171:        static void
        -:  172:        __destroy(_ForwardIterator, _ForwardIterator) { }
        -:  173:    };
        -:  174:
        -:  175:  /**
        -:  176:   * Destroy a range of objects.  If the value_type of the object has
        -:  177:   * a trivial destructor, the compiler should optimize all of this
        -:  178:   * away, otherwise the objects' destructors must be invoked.
        -:  179:   */
        -:  180:  template<typename _ForwardIterator>
        -:  181:    _GLIBCXX20_CONSTEXPR inline void
    63713:  182:    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
        -:  183:    {
        -:  184:      typedef typename iterator_traits<_ForwardIterator>::value_type
        -:  185:                       _Value_type;
        -:  186:#if __cplusplus >= 201103L
        -:  187:      // A deleted destructor is trivial, this ensures we reject such types:
        -:  188:      static_assert(is_destructible<_Value_type>::value,
        -:  189:		    "value type is destructible");
        -:  190:#endif
        -:  191:#if __cpp_constexpr_dynamic_alloc // >= C++20
        -:  192:      if (std::__is_constant_evaluated())
        -:  193:	return std::_Destroy_aux<false>::__destroy(__first, __last);
        -:  194:#endif
        -:  195:      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
    63713:  196:	__destroy(__first, __last);
    63713:  196-block 2
вызов    0 вернул 63713
        -:  197:    }
        -:  198:
        -:  199:  template<bool>
        -:  200:    struct _Destroy_n_aux
        -:  201:    {
        -:  202:      template<typename _ForwardIterator, typename _Size>
        -:  203:	static _GLIBCXX20_CONSTEXPR _ForwardIterator
        -:  204:	__destroy_n(_ForwardIterator __first, _Size __count)
        -:  205:	{
        -:  206:	  for (; __count > 0; (void)++__first, --__count)
        -:  207:	    std::_Destroy(std::__addressof(*__first));
        -:  208:	  return __first;
        -:  209:	}
        -:  210:    };
        -:  211:
        -:  212:  template<>
        -:  213:    struct _Destroy_n_aux<true>
        -:  214:    {
        -:  215:      template<typename _ForwardIterator, typename _Size>
        -:  216:        static _ForwardIterator
        -:  217:        __destroy_n(_ForwardIterator __first, _Size __count)
        -:  218:	{
        -:  219:	  std::advance(__first, __count);
        -:  220:	  return __first;
        -:  221:	}
        -:  222:    };
        -:  223:
        -:  224:  /**
        -:  225:   * Destroy a range of objects.  If the value_type of the object has
        -:  226:   * a trivial destructor, the compiler should optimize all of this
        -:  227:   * away, otherwise the objects' destructors must be invoked.
        -:  228:   */
        -:  229:  template<typename _ForwardIterator, typename _Size>
        -:  230:    _GLIBCXX20_CONSTEXPR inline _ForwardIterator
        -:  231:    _Destroy_n(_ForwardIterator __first, _Size __count)
        -:  232:    {
        -:  233:      typedef typename iterator_traits<_ForwardIterator>::value_type
        -:  234:                       _Value_type;
        -:  235:#if __cplusplus >= 201103L
        -:  236:      // A deleted destructor is trivial, this ensures we reject such types:
        -:  237:      static_assert(is_destructible<_Value_type>::value,
        -:  238:		    "value type is destructible");
        -:  239:#endif
        -:  240:#if __cpp_constexpr_dynamic_alloc // >= C++20
        -:  241:      if (std::__is_constant_evaluated())
        -:  242:	return std::_Destroy_n_aux<false>::__destroy_n(__first, __count);
        -:  243:#endif
        -:  244:      return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
        -:  245:	__destroy_n(__first, __count);
        -:  246:    }
        -:  247:
        -:  248:#if __glibcxx_raw_memory_algorithms // >= C++17
        -:  249:  template <typename _ForwardIterator>
        -:  250:    _GLIBCXX20_CONSTEXPR inline void
        -:  251:    destroy(_ForwardIterator __first, _ForwardIterator __last)
        -:  252:    {
        -:  253:      std::_Destroy(__first, __last);
        -:  254:    }
        -:  255:
        -:  256:  template <typename _ForwardIterator, typename _Size>
        -:  257:    _GLIBCXX20_CONSTEXPR inline _ForwardIterator
        -:  258:    destroy_n(_ForwardIterator __first, _Size __count)
        -:  259:    {
        -:  260:      return std::_Destroy_n(__first, __count);
        -:  261:    }
        -:  262:#endif // C++17
        -:  263:
        -:  264:_GLIBCXX_END_NAMESPACE_VERSION
        -:  265:} // namespace std
        -:  266:
        -:  267:#endif /* _STL_CONSTRUCT_H */
